home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 March / PCWorld_2007-03_cd.bin / domacnost a kancelar / scribus / scribus-1.3.3.7-win32-install.exe / lib / compiler / ast.py < prev    next >
Text File  |  2004-10-15  |  36KB  |  1,317 lines
  1. """Python abstract syntax node definitions
  2.  
  3. This file is automatically generated by Tools/compiler/astgen.py
  4. """
  5. from consts import CO_VARARGS, CO_VARKEYWORDS
  6.  
  7. def flatten(list):
  8.     l = []
  9.     for elt in list:
  10.         t = type(elt)
  11.         if t is tuple or t is list:
  12.             for elt2 in flatten(elt):
  13.                 l.append(elt2)
  14.         else:
  15.             l.append(elt)
  16.     return l
  17.  
  18. def flatten_nodes(list):
  19.     return [n for n in flatten(list) if isinstance(n, Node)]
  20.  
  21. nodes = {}
  22.  
  23. class Node:
  24.     """Abstract base class for ast nodes."""
  25.     def getChildren(self):
  26.         pass # implemented by subclasses
  27.     def __iter__(self):
  28.         for n in self.getChildren():
  29.             yield n
  30.     def asList(self): # for backwards compatibility
  31.         return self.getChildren()
  32.     def getChildNodes(self):
  33.         pass # implemented by subclasses
  34.  
  35. class EmptyNode(Node):
  36.     pass
  37.  
  38. class Expression(Node):
  39.     # Expression is an artificial node class to support "eval"
  40.     nodes["expression"] = "Expression"
  41.     def __init__(self, node):
  42.         self.node = node
  43.  
  44.     def getChildren(self):
  45.         return self.node,
  46.  
  47.     def getChildNodes(self):
  48.         return self.node,
  49.  
  50.     def __repr__(self):
  51.         return "Expression(%s)" % (repr(self.node))
  52.  
  53. class Add(Node):
  54.     def __init__(self, (left, right), lineno=None):
  55.         self.left = left
  56.         self.right = right
  57.         self.lineno = lineno
  58.  
  59.     def getChildren(self):
  60.         return self.left, self.right
  61.  
  62.     def getChildNodes(self):
  63.         return self.left, self.right
  64.  
  65.     def __repr__(self):
  66.         return "Add((%s, %s))" % (repr(self.left), repr(self.right))
  67.  
  68. class And(Node):
  69.     def __init__(self, nodes, lineno=None):
  70.         self.nodes = nodes
  71.         self.lineno = lineno
  72.  
  73.     def getChildren(self):
  74.         return tuple(flatten(self.nodes))
  75.  
  76.     def getChildNodes(self):
  77.         nodelist = []
  78.         nodelist.extend(flatten_nodes(self.nodes))
  79.         return tuple(nodelist)
  80.  
  81.     def __repr__(self):
  82.         return "And(%s)" % (repr(self.nodes),)
  83.  
  84. class AssAttr(Node):
  85.     def __init__(self, expr, attrname, flags, lineno=None):
  86.         self.expr = expr
  87.         self.attrname = attrname
  88.         self.flags = flags
  89.         self.lineno = lineno
  90.  
  91.     def getChildren(self):
  92.         return self.expr, self.attrname, self.flags
  93.  
  94.     def getChildNodes(self):
  95.         return self.expr,
  96.  
  97.     def __repr__(self):
  98.         return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
  99.  
  100. class AssList(Node):
  101.     def __init__(self, nodes, lineno=None):
  102.         self.nodes = nodes
  103.         self.lineno = lineno
  104.  
  105.     def getChildren(self):
  106.         return tuple(flatten(self.nodes))
  107.  
  108.     def getChildNodes(self):
  109.         nodelist = []
  110.         nodelist.extend(flatten_nodes(self.nodes))
  111.         return tuple(nodelist)
  112.  
  113.     def __repr__(self):
  114.         return "AssList(%s)" % (repr(self.nodes),)
  115.  
  116. class AssName(Node):
  117.     def __init__(self, name, flags, lineno=None):
  118.         self.name = name
  119.         self.flags = flags
  120.         self.lineno = lineno
  121.  
  122.     def getChildren(self):
  123.         return self.name, self.flags
  124.  
  125.     def getChildNodes(self):
  126.         return ()
  127.  
  128.     def __repr__(self):
  129.         return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
  130.  
  131. class AssTuple(Node):
  132.     def __init__(self, nodes, lineno=None):
  133.         self.nodes = nodes
  134.         self.lineno = lineno
  135.  
  136.     def getChildren(self):
  137.         return tuple(flatten(self.nodes))
  138.  
  139.     def getChildNodes(self):
  140.         nodelist = []
  141.         nodelist.extend(flatten_nodes(self.nodes))
  142.         return tuple(nodelist)
  143.  
  144.     def __repr__(self):
  145.         return "AssTuple(%s)" % (repr(self.nodes),)
  146.  
  147. class Assert(Node):
  148.     def __init__(self, test, fail, lineno=None):
  149.         self.test = test
  150.         self.fail = fail
  151.         self.lineno = lineno
  152.  
  153.     def getChildren(self):
  154.         children = []
  155.         children.append(self.test)
  156.         children.append(self.fail)
  157.         return tuple(children)
  158.  
  159.     def getChildNodes(self):
  160.         nodelist = []
  161.         nodelist.append(self.test)
  162.         if self.fail is not None:
  163.             nodelist.append(self.fail)
  164.         return tuple(nodelist)
  165.  
  166.     def __repr__(self):
  167.         return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
  168.  
  169. class Assign(Node):
  170.     def __init__(self, nodes, expr, lineno=None):
  171.         self.nodes = nodes
  172.         self.expr = expr
  173.         self.lineno = lineno
  174.  
  175.     def getChildren(self):
  176.         children = []
  177.         children.extend(flatten(self.nodes))
  178.         children.append(self.expr)
  179.         return tuple(children)
  180.  
  181.     def getChildNodes(self):
  182.         nodelist = []
  183.         nodelist.extend(flatten_nodes(self.nodes))
  184.         nodelist.append(self.expr)
  185.         return tuple(nodelist)
  186.  
  187.     def __repr__(self):
  188.         return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
  189.  
  190. class AugAssign(Node):
  191.     def __init__(self, node, op, expr, lineno=None):
  192.         self.node = node
  193.         self.op = op
  194.         self.expr = expr
  195.         self.lineno = lineno
  196.  
  197.     def getChildren(self):
  198.         return self.node, self.op, self.expr
  199.  
  200.     def getChildNodes(self):
  201.         return self.node, self.expr
  202.  
  203.     def __repr__(self):
  204.         return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
  205.  
  206. class Backquote(Node):
  207.     def __init__(self, expr, lineno=None):
  208.         self.expr = expr
  209.         self.lineno = lineno
  210.  
  211.     def getChildren(self):
  212.         return self.expr,
  213.  
  214.     def getChildNodes(self):
  215.         return self.expr,
  216.  
  217.     def __repr__(self):
  218.         return "Backquote(%s)" % (repr(self.expr),)
  219.  
  220. class Bitand(Node):
  221.     def __init__(self, nodes, lineno=None):
  222.         self.nodes = nodes
  223.         self.lineno = lineno
  224.  
  225.     def getChildren(self):
  226.         return tuple(flatten(self.nodes))
  227.  
  228.     def getChildNodes(self):
  229.         nodelist = []
  230.         nodelist.extend(flatten_nodes(self.nodes))
  231.         return tuple(nodelist)
  232.  
  233.     def __repr__(self):
  234.         return "Bitand(%s)" % (repr(self.nodes),)
  235.  
  236. class Bitor(Node):
  237.     def __init__(self, nodes, lineno=None):
  238.         self.nodes = nodes
  239.         self.lineno = lineno
  240.  
  241.     def getChildren(self):
  242.         return tuple(flatten(self.nodes))
  243.  
  244.     def getChildNodes(self):
  245.         nodelist = []
  246.         nodelist.extend(flatten_nodes(self.nodes))
  247.         return tuple(nodelist)
  248.  
  249.     def __repr__(self):
  250.         return "Bitor(%s)" % (repr(self.nodes),)
  251.  
  252. class Bitxor(Node):
  253.     def __init__(self, nodes, lineno=None):
  254.         self.nodes = nodes
  255.         self.lineno = lineno
  256.  
  257.     def getChildren(self):
  258.         return tuple(flatten(self.nodes))
  259.  
  260.     def getChildNodes(self):
  261.         nodelist = []
  262.         nodelist.extend(flatten_nodes(self.nodes))
  263.         return tuple(nodelist)
  264.  
  265.     def __repr__(self):
  266.         return "Bitxor(%s)" % (repr(self.nodes),)
  267.  
  268. class Break(Node):
  269.     def __init__(self, lineno=None):
  270.         self.lineno = lineno
  271.  
  272.     def getChildren(self):
  273.         return ()
  274.  
  275.     def getChildNodes(self):
  276.         return ()
  277.  
  278.     def __repr__(self):
  279.         return "Break()"
  280.  
  281. class CallFunc(Node):
  282.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
  283.         self.node = node
  284.         self.args = args
  285.         self.star_args = star_args
  286.         self.dstar_args = dstar_args
  287.         self.lineno = lineno
  288.  
  289.     def getChildren(self):
  290.         children = []
  291.         children.append(self.node)
  292.         children.extend(flatten(self.args))
  293.         children.append(self.star_args)
  294.         children.append(self.dstar_args)
  295.         return tuple(children)
  296.  
  297.     def getChildNodes(self):
  298.         nodelist = []
  299.         nodelist.append(self.node)
  300.         nodelist.extend(flatten_nodes(self.args))
  301.         if self.star_args is not None:
  302.             nodelist.append(self.star_args)
  303.         if self.dstar_args is not None:
  304.             nodelist.append(self.dstar_args)
  305.         return tuple(nodelist)
  306.  
  307.     def __repr__(self):
  308.         return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  309.  
  310. class Class(Node):
  311.     def __init__(self, name, bases, doc, code, lineno=None):
  312.         self.name = name
  313.         self.bases = bases
  314.         self.doc = doc
  315.         self.code = code
  316.         self.lineno = lineno
  317.  
  318.     def getChildren(self):
  319.         children = []
  320.         children.append(self.name)
  321.         children.extend(flatten(self.bases))
  322.         children.append(self.doc)
  323.         children.append(self.code)
  324.         return tuple(children)
  325.  
  326.     def getChildNodes(self):
  327.         nodelist = []
  328.         nodelist.extend(flatten_nodes(self.bases))
  329.         nodelist.append(self.code)
  330.         return tuple(nodelist)
  331.  
  332.     def __repr__(self):
  333.         return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
  334.  
  335. class Compare(Node):
  336.     def __init__(self, expr, ops, lineno=None):
  337.         self.expr = expr
  338.         self.ops = ops
  339.         self.lineno = lineno
  340.  
  341.     def getChildren(self):
  342.         children = []
  343.         children.append(self.expr)
  344.         children.extend(flatten(self.ops))
  345.         return tuple(children)
  346.  
  347.     def getChildNodes(self):
  348.         nodelist = []
  349.         nodelist.append(self.expr)
  350.         nodelist.extend(flatten_nodes(self.ops))
  351.         return tuple(nodelist)
  352.  
  353.     def __repr__(self):
  354.         return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
  355.  
  356. class Const(Node):
  357.     def __init__(self, value, lineno=None):
  358.         self.value = value
  359.         self.lineno = lineno
  360.  
  361.     def getChildren(self):
  362.         return self.value,
  363.  
  364.     def getChildNodes(self):
  365.         return ()
  366.  
  367.     def __repr__(self):
  368.         return "Const(%s)" % (repr(self.value),)
  369.  
  370. class Continue(Node):
  371.     def __init__(self, lineno=None):
  372.         self.lineno = lineno
  373.  
  374.     def getChildren(self):
  375.         return ()
  376.  
  377.     def getChildNodes(self):
  378.         return ()
  379.  
  380.     def __repr__(self):
  381.         return "Continue()"
  382.  
  383. class Decorators(Node):
  384.     def __init__(self, nodes, lineno=None):
  385.         self.nodes = nodes
  386.         self.lineno = lineno
  387.  
  388.     def getChildren(self):
  389.         return tuple(flatten(self.nodes))
  390.  
  391.     def getChildNodes(self):
  392.         nodelist = []
  393.         nodelist.extend(flatten_nodes(self.nodes))
  394.         return tuple(nodelist)
  395.  
  396.     def __repr__(self):
  397.         return "Decorators(%s)" % (repr(self.nodes),)
  398.  
  399. class Dict(Node):
  400.     def __init__(self, items, lineno=None):
  401.         self.items = items
  402.         self.lineno = lineno
  403.  
  404.     def getChildren(self):
  405.         return tuple(flatten(self.items))
  406.  
  407.     def getChildNodes(self):
  408.         nodelist = []
  409.         nodelist.extend(flatten_nodes(self.items))
  410.         return tuple(nodelist)
  411.  
  412.     def __repr__(self):
  413.         return "Dict(%s)" % (repr(self.items),)
  414.  
  415. class Discard(Node):
  416.     def __init__(self, expr, lineno=None):
  417.         self.expr = expr
  418.         self.lineno = lineno
  419.  
  420.     def getChildren(self):
  421.         return self.expr,
  422.  
  423.     def getChildNodes(self):
  424.         return self.expr,
  425.  
  426.     def __repr__(self):
  427.         return "Discard(%s)" % (repr(self.expr),)
  428.  
  429. class Div(Node):
  430.     def __init__(self, (left, right), lineno=None):
  431.         self.left = left
  432.         self.right = right
  433.         self.lineno = lineno
  434.  
  435.     def getChildren(self):
  436.         return self.left, self.right
  437.  
  438.     def getChildNodes(self):
  439.         return self.left, self.right
  440.  
  441.     def __repr__(self):
  442.         return "Div((%s, %s))" % (repr(self.left), repr(self.right))
  443.  
  444. class Ellipsis(Node):
  445.     def __init__(self, lineno=None):
  446.         self.lineno = lineno
  447.  
  448.     def getChildren(self):
  449.         return ()
  450.  
  451.     def getChildNodes(self):
  452.         return ()
  453.  
  454.     def __repr__(self):
  455.         return "Ellipsis()"
  456.  
  457. class Exec(Node):
  458.     def __init__(self, expr, locals, globals, lineno=None):
  459.         self.expr = expr
  460.         self.locals = locals
  461.         self.globals = globals
  462.         self.lineno = lineno
  463.  
  464.     def getChildren(self):
  465.         children = []
  466.         children.append(self.expr)
  467.         children.append(self.locals)
  468.         children.append(self.globals)
  469.         return tuple(children)
  470.  
  471.     def getChildNodes(self):
  472.         nodelist = []
  473.         nodelist.append(self.expr)
  474.         if self.locals is not None:
  475.             nodelist.append(self.locals)
  476.         if self.globals is not None:
  477.             nodelist.append(self.globals)
  478.         return tuple(nodelist)
  479.  
  480.     def __repr__(self):
  481.         return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
  482.  
  483. class FloorDiv(Node):
  484.     def __init__(self, (left, right), lineno=None):
  485.         self.left = left
  486.         self.right = right
  487.         self.lineno = lineno
  488.  
  489.     def getChildren(self):
  490.         return self.left, self.right
  491.  
  492.     def getChildNodes(self):
  493.         return self.left, self.right
  494.  
  495.     def __repr__(self):
  496.         return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
  497.  
  498. class For(Node):
  499.     def __init__(self, assign, list, body, else_, lineno=None):
  500.         self.assign = assign
  501.         self.list = list
  502.         self.body = body
  503.         self.else_ = else_
  504.         self.lineno = lineno
  505.  
  506.     def getChildren(self):
  507.         children = []
  508.         children.append(self.assign)
  509.         children.append(self.list)
  510.         children.append(self.body)
  511.         children.append(self.else_)
  512.         return tuple(children)
  513.  
  514.     def getChildNodes(self):
  515.         nodelist = []
  516.         nodelist.append(self.assign)
  517.         nodelist.append(self.list)
  518.         nodelist.append(self.body)
  519.         if self.else_ is not None:
  520.             nodelist.append(self.else_)
  521.         return tuple(nodelist)
  522.  
  523.     def __repr__(self):
  524.         return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  525.  
  526. class From(Node):
  527.     def __init__(self, modname, names, lineno=None):
  528.         self.modname = modname
  529.         self.names = names
  530.         self.lineno = lineno
  531.  
  532.     def getChildren(self):
  533.         return self.modname, self.names
  534.  
  535.     def getChildNodes(self):
  536.         return ()
  537.  
  538.     def __repr__(self):
  539.         return "From(%s, %s)" % (repr(self.modname), repr(self.names))
  540.  
  541. class Function(Node):
  542.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
  543.         self.decorators = decorators
  544.         self.name = name
  545.         self.argnames = argnames
  546.         self.defaults = defaults
  547.         self.flags = flags
  548.         self.doc = doc
  549.         self.code = code
  550.         self.lineno = lineno
  551.         self.varargs = self.kwargs = None
  552.         if flags & CO_VARARGS:
  553.             self.varargs = 1
  554.         if flags & CO_VARKEYWORDS:
  555.             self.kwargs = 1
  556.  
  557.  
  558.  
  559.     def getChildren(self):
  560.         children = []
  561.         children.append(self.decorators)
  562.         children.append(self.name)
  563.         children.append(self.argnames)
  564.         children.extend(flatten(self.defaults))
  565.         children.append(self.flags)
  566.         children.append(self.doc)
  567.         children.append(self.code)
  568.         return tuple(children)
  569.  
  570.     def getChildNodes(self):
  571.         nodelist = []
  572.         if self.decorators is not None:
  573.             nodelist.append(self.decorators)
  574.         nodelist.extend(flatten_nodes(self.defaults))
  575.         nodelist.append(self.code)
  576.         return tuple(nodelist)
  577.  
  578.     def __repr__(self):
  579.         return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  580.  
  581. class GenExpr(Node):
  582.     def __init__(self, code, lineno=None):
  583.         self.code = code
  584.         self.lineno = lineno
  585.         self.argnames = ['[outmost-iterable]']
  586.         self.varargs = self.kwargs = None
  587.  
  588.  
  589.  
  590.     def getChildren(self):
  591.         return self.code,
  592.  
  593.     def getChildNodes(self):
  594.         return self.code,
  595.  
  596.     def __repr__(self):
  597.         return "GenExpr(%s)" % (repr(self.code),)
  598.  
  599. class GenExprFor(Node):
  600.     def __init__(self, assign, iter, ifs, lineno=None):
  601.         self.assign = assign
  602.         self.iter = iter
  603.         self.ifs = ifs
  604.         self.lineno = lineno
  605.         self.is_outmost = False
  606.  
  607.  
  608.     def getChildren(self):
  609.         children = []
  610.         children.append(self.assign)
  611.         children.append(self.iter)
  612.         children.extend(flatten(self.ifs))
  613.         return tuple(children)
  614.  
  615.     def getChildNodes(self):
  616.         nodelist = []
  617.         nodelist.append(self.assign)
  618.         nodelist.append(self.iter)
  619.         nodelist.extend(flatten_nodes(self.ifs))
  620.         return tuple(nodelist)
  621.  
  622.     def __repr__(self):
  623.         return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
  624.  
  625. class GenExprIf(Node):
  626.     def __init__(self, test, lineno=None):
  627.         self.test = test
  628.         self.lineno = lineno
  629.  
  630.     def getChildren(self):
  631.         return self.test,
  632.  
  633.     def getChildNodes(self):
  634.         return self.test,
  635.  
  636.     def __repr__(self):
  637.         return "GenExprIf(%s)" % (repr(self.test),)
  638.  
  639. class GenExprInner(Node):
  640.     def __init__(self, expr, quals, lineno=None):
  641.         self.expr = expr
  642.         self.quals = quals
  643.         self.lineno = lineno
  644.  
  645.     def getChildren(self):
  646.         children = []
  647.         children.append(self.expr)
  648.         children.extend(flatten(self.quals))
  649.         return tuple(children)
  650.  
  651.     def getChildNodes(self):
  652.         nodelist = []
  653.         nodelist.append(self.expr)
  654.         nodelist.extend(flatten_nodes(self.quals))
  655.         return tuple(nodelist)
  656.  
  657.     def __repr__(self):
  658.         return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
  659.  
  660. class Getattr(Node):
  661.     def __init__(self, expr, attrname, lineno=None):
  662.         self.expr = expr
  663.         self.attrname = attrname
  664.         self.lineno = lineno
  665.  
  666.     def getChildren(self):
  667.         return self.expr, self.attrname
  668.  
  669.     def getChildNodes(self):
  670.         return self.expr,
  671.  
  672.     def __repr__(self):
  673.         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
  674.  
  675. class Global(Node):
  676.     def __init__(self, names, lineno=None):
  677.         self.names = names
  678.         self.lineno = lineno
  679.  
  680.     def getChildren(self):
  681.         return self.names,
  682.  
  683.     def getChildNodes(self):
  684.         return ()
  685.  
  686.     def __repr__(self):
  687.         return "Global(%s)" % (repr(self.names),)
  688.  
  689. class If(Node):
  690.     def __init__(self, tests, else_, lineno=None):
  691.         self.tests = tests
  692.         self.else_ = else_
  693.         self.lineno = lineno
  694.  
  695.     def getChildren(self):
  696.         children = []
  697.         children.extend(flatten(self.tests))
  698.         children.append(self.else_)
  699.         return tuple(children)
  700.  
  701.     def getChildNodes(self):
  702.         nodelist = []
  703.         nodelist.extend(flatten_nodes(self.tests))
  704.         if self.else_ is not None:
  705.             nodelist.append(self.else_)
  706.         return tuple(nodelist)
  707.  
  708.     def __repr__(self):
  709.         return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
  710.  
  711. class Import(Node):
  712.     def __init__(self, names, lineno=None):
  713.         self.names = names
  714.         self.lineno = lineno
  715.  
  716.     def getChildren(self):
  717.         return self.names,
  718.  
  719.     def getChildNodes(self):
  720.         return ()
  721.  
  722.     def __repr__(self):
  723.         return "Import(%s)" % (repr(self.names),)
  724.  
  725. class Invert(Node):
  726.     def __init__(self, expr, lineno=None):
  727.         self.expr = expr
  728.         self.lineno = lineno
  729.  
  730.     def getChildren(self):
  731.         return self.expr,
  732.  
  733.     def getChildNodes(self):
  734.         return self.expr,
  735.  
  736.     def __repr__(self):
  737.         return "Invert(%s)" % (repr(self.expr),)
  738.  
  739. class Keyword(Node):
  740.     def __init__(self, name, expr, lineno=None):
  741.         self.name = name
  742.         self.expr = expr
  743.         self.lineno = lineno
  744.  
  745.     def getChildren(self):
  746.         return self.name, self.expr
  747.  
  748.     def getChildNodes(self):
  749.         return self.expr,
  750.  
  751.     def __repr__(self):
  752.         return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
  753.  
  754. class Lambda(Node):
  755.     def __init__(self, argnames, defaults, flags, code, lineno=None):
  756.         self.argnames = argnames
  757.         self.defaults = defaults
  758.         self.flags = flags
  759.         self.code = code
  760.         self.lineno = lineno
  761.         self.varargs = self.kwargs = None
  762.         if flags & CO_VARARGS:
  763.             self.varargs = 1
  764.         if flags & CO_VARKEYWORDS:
  765.             self.kwargs = 1
  766.  
  767.  
  768.  
  769.     def getChildren(self):
  770.         children = []
  771.         children.append(self.argnames)
  772.         children.extend(flatten(self.defaults))
  773.         children.append(self.flags)
  774.         children.append(self.code)
  775.         return tuple(children)
  776.  
  777.     def getChildNodes(self):
  778.         nodelist = []
  779.         nodelist.extend(flatten_nodes(self.defaults))
  780.         nodelist.append(self.code)
  781.         return tuple(nodelist)
  782.  
  783.     def __repr__(self):
  784.         return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  785.  
  786. class LeftShift(Node):
  787.     def __init__(self, (left, right), lineno=None):
  788.         self.left = left
  789.         self.right = right
  790.         self.lineno = lineno
  791.  
  792.     def getChildren(self):
  793.         return self.left, self.right
  794.  
  795.     def getChildNodes(self):
  796.         return self.left, self.right
  797.  
  798.     def __repr__(self):
  799.         return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
  800.  
  801. class List(Node):
  802.     def __init__(self, nodes, lineno=None):
  803.         self.nodes = nodes
  804.         self.lineno = lineno
  805.  
  806.     def getChildren(self):
  807.         return tuple(flatten(self.nodes))
  808.  
  809.     def getChildNodes(self):
  810.         nodelist = []
  811.         nodelist.extend(flatten_nodes(self.nodes))
  812.         return tuple(nodelist)
  813.  
  814.     def __repr__(self):
  815.         return "List(%s)" % (repr(self.nodes),)
  816.  
  817. class ListComp(Node):
  818.     def __init__(self, expr, quals, lineno=None):
  819.         self.expr = expr
  820.         self.quals = quals
  821.         self.lineno = lineno
  822.  
  823.     def getChildren(self):
  824.         children = []
  825.         children.append(self.expr)
  826.         children.extend(flatten(self.quals))
  827.         return tuple(children)
  828.  
  829.     def getChildNodes(self):
  830.         nodelist = []
  831.         nodelist.append(self.expr)
  832.         nodelist.extend(flatten_nodes(self.quals))
  833.         return tuple(nodelist)
  834.  
  835.     def __repr__(self):
  836.         return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
  837.  
  838. class ListCompFor(Node):
  839.     def __init__(self, assign, list, ifs, lineno=None):
  840.         self.assign = assign
  841.         self.list = list
  842.         self.ifs = ifs
  843.         self.lineno = lineno
  844.  
  845.     def getChildren(self):
  846.         children = []
  847.         children.append(self.assign)
  848.         children.append(self.list)
  849.         children.extend(flatten(self.ifs))
  850.         return tuple(children)
  851.  
  852.     def getChildNodes(self):
  853.         nodelist = []
  854.         nodelist.append(self.assign)
  855.         nodelist.append(self.list)
  856.         nodelist.extend(flatten_nodes(self.ifs))
  857.         return tuple(nodelist)
  858.  
  859.     def __repr__(self):
  860.         return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
  861.  
  862. class ListCompIf(Node):
  863.     def __init__(self, test, lineno=None):
  864.         self.test = test
  865.         self.lineno = lineno
  866.  
  867.     def getChildren(self):
  868.         return self.test,
  869.  
  870.     def getChildNodes(self):
  871.         return self.test,
  872.  
  873.     def __repr__(self):
  874.         return "ListCompIf(%s)" % (repr(self.test),)
  875.  
  876. class Mod(Node):
  877.     def __init__(self, (left, right), lineno=None):
  878.         self.left = left
  879.         self.right = right
  880.         self.lineno = lineno
  881.  
  882.     def getChildren(self):
  883.         return self.left, self.right
  884.  
  885.     def getChildNodes(self):
  886.         return self.left, self.right
  887.  
  888.     def __repr__(self):
  889.         return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
  890.  
  891. class Module(Node):
  892.     def __init__(self, doc, node, lineno=None):
  893.         self.doc = doc
  894.         self.node = node
  895.         self.lineno = lineno
  896.  
  897.     def getChildren(self):
  898.         return self.doc, self.node
  899.  
  900.     def getChildNodes(self):
  901.         return self.node,
  902.  
  903.     def __repr__(self):
  904.         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
  905.  
  906. class Mul(Node):
  907.     def __init__(self, (left, right), lineno=None):
  908.         self.left = left
  909.         self.right = right
  910.         self.lineno = lineno
  911.  
  912.     def getChildren(self):
  913.         return self.left, self.right
  914.  
  915.     def getChildNodes(self):
  916.         return self.left, self.right
  917.  
  918.     def __repr__(self):
  919.         return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
  920.  
  921. class Name(Node):
  922.     def __init__(self, name, lineno=None):
  923.         self.name = name
  924.         self.lineno = lineno
  925.  
  926.     def getChildren(self):
  927.         return self.name,
  928.  
  929.     def getChildNodes(self):
  930.         return ()
  931.  
  932.     def __repr__(self):
  933.         return "Name(%s)" % (repr(self.name),)
  934.  
  935. class Not(Node):
  936.     def __init__(self, expr, lineno=None):
  937.         self.expr = expr
  938.         self.lineno = lineno
  939.  
  940.     def getChildren(self):
  941.         return self.expr,
  942.  
  943.     def getChildNodes(self):
  944.         return self.expr,
  945.  
  946.     def __repr__(self):
  947.         return "Not(%s)" % (repr(self.expr),)
  948.  
  949. class Or(Node):
  950.     def __init__(self, nodes, lineno=None):
  951.         self.nodes = nodes
  952.         self.lineno = lineno
  953.  
  954.     def getChildren(self):
  955.         return tuple(flatten(self.nodes))
  956.  
  957.     def getChildNodes(self):
  958.         nodelist = []
  959.         nodelist.extend(flatten_nodes(self.nodes))
  960.         return tuple(nodelist)
  961.  
  962.     def __repr__(self):
  963.         return "Or(%s)" % (repr(self.nodes),)
  964.  
  965. class Pass(Node):
  966.     def __init__(self, lineno=None):
  967.         self.lineno = lineno
  968.  
  969.     def getChildren(self):
  970.         return ()
  971.  
  972.     def getChildNodes(self):
  973.         return ()
  974.  
  975.     def __repr__(self):
  976.         return "Pass()"
  977.  
  978. class Power(Node):
  979.     def __init__(self, (left, right), lineno=None):
  980.         self.left = left
  981.         self.right = right
  982.         self.lineno = lineno
  983.  
  984.     def getChildren(self):
  985.         return self.left, self.right
  986.  
  987.     def getChildNodes(self):
  988.         return self.left, self.right
  989.  
  990.     def __repr__(self):
  991.         return "Power((%s, %s))" % (repr(self.left), repr(self.right))
  992.  
  993. class Print(Node):
  994.     def __init__(self, nodes, dest, lineno=None):
  995.         self.nodes = nodes
  996.         self.dest = dest
  997.         self.lineno = lineno
  998.  
  999.     def getChildren(self):
  1000.         children = []
  1001.         children.extend(flatten(self.nodes))
  1002.         children.append(self.dest)
  1003.         return tuple(children)
  1004.  
  1005.     def getChildNodes(self):
  1006.         nodelist = []
  1007.         nodelist.extend(flatten_nodes(self.nodes))
  1008.         if self.dest is not None:
  1009.             nodelist.append(self.dest)
  1010.         return tuple(nodelist)
  1011.  
  1012.     def __repr__(self):
  1013.         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1014.  
  1015. class Printnl(Node):
  1016.     def __init__(self, nodes, dest, lineno=None):
  1017.         self.nodes = nodes
  1018.         self.dest = dest
  1019.         self.lineno = lineno
  1020.  
  1021.     def getChildren(self):
  1022.         children = []
  1023.         children.extend(flatten(self.nodes))
  1024.         children.append(self.dest)
  1025.         return tuple(children)
  1026.  
  1027.     def getChildNodes(self):
  1028.         nodelist = []
  1029.         nodelist.extend(flatten_nodes(self.nodes))
  1030.         if self.dest is not None:
  1031.             nodelist.append(self.dest)
  1032.         return tuple(nodelist)
  1033.  
  1034.     def __repr__(self):
  1035.         return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1036.  
  1037. class Raise(Node):
  1038.     def __init__(self, expr1, expr2, expr3, lineno=None):
  1039.         self.expr1 = expr1
  1040.         self.expr2 = expr2
  1041.         self.expr3 = expr3
  1042.         self.lineno = lineno
  1043.  
  1044.     def getChildren(self):
  1045.         children = []
  1046.         children.append(self.expr1)
  1047.         children.append(self.expr2)
  1048.         children.append(self.expr3)
  1049.         return tuple(children)
  1050.  
  1051.     def getChildNodes(self):
  1052.         nodelist = []
  1053.         if self.expr1 is not None:
  1054.             nodelist.append(self.expr1)
  1055.         if self.expr2 is not None:
  1056.             nodelist.append(self.expr2)
  1057.         if self.expr3 is not None:
  1058.             nodelist.append(self.expr3)
  1059.         return tuple(nodelist)
  1060.  
  1061.     def __repr__(self):
  1062.         return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1063.  
  1064. class Return(Node):
  1065.     def __init__(self, value, lineno=None):
  1066.         self.value = value
  1067.         self.lineno = lineno
  1068.  
  1069.     def getChildren(self):
  1070.         return self.value,
  1071.  
  1072.     def getChildNodes(self):
  1073.         return self.value,
  1074.  
  1075.     def __repr__(self):
  1076.         return "Return(%s)" % (repr(self.value),)
  1077.  
  1078. class RightShift(Node):
  1079.     def __init__(self, (left, right), lineno=None):
  1080.         self.left = left
  1081.         self.right = right
  1082.         self.lineno = lineno
  1083.  
  1084.     def getChildren(self):
  1085.         return self.left, self.right
  1086.  
  1087.     def getChildNodes(self):
  1088.         return self.left, self.right
  1089.  
  1090.     def __repr__(self):
  1091.         return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
  1092.  
  1093. class Slice(Node):
  1094.     def __init__(self, expr, flags, lower, upper, lineno=None):
  1095.         self.expr = expr
  1096.         self.flags = flags
  1097.         self.lower = lower
  1098.         self.upper = upper
  1099.         self.lineno = lineno
  1100.  
  1101.     def getChildren(self):
  1102.         children = []
  1103.         children.append(self.expr)
  1104.         children.append(self.flags)
  1105.         children.append(self.lower)
  1106.         children.append(self.upper)
  1107.         return tuple(children)
  1108.  
  1109.     def getChildNodes(self):
  1110.         nodelist = []
  1111.         nodelist.append(self.expr)
  1112.         if self.lower is not None:
  1113.             nodelist.append(self.lower)
  1114.         if self.upper is not None:
  1115.             nodelist.append(self.upper)
  1116.         return tuple(nodelist)
  1117.  
  1118.     def __repr__(self):
  1119.         return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1120.  
  1121. class Sliceobj(Node):
  1122.     def __init__(self, nodes, lineno=None):
  1123.         self.nodes = nodes
  1124.         self.lineno = lineno
  1125.  
  1126.     def getChildren(self):
  1127.         return tuple(flatten(self.nodes))
  1128.  
  1129.     def getChildNodes(self):
  1130.         nodelist = []
  1131.         nodelist.extend(flatten_nodes(self.nodes))
  1132.         return tuple(nodelist)
  1133.  
  1134.     def __repr__(self):
  1135.         return "Sliceobj(%s)" % (repr(self.nodes),)
  1136.  
  1137. class Stmt(Node):
  1138.     def __init__(self, nodes, lineno=None):
  1139.         self.nodes = nodes
  1140.         self.lineno = lineno
  1141.  
  1142.     def getChildren(self):
  1143.         return tuple(flatten(self.nodes))
  1144.  
  1145.     def getChildNodes(self):
  1146.         nodelist = []
  1147.         nodelist.extend(flatten_nodes(self.nodes))
  1148.         return tuple(nodelist)
  1149.  
  1150.     def __repr__(self):
  1151.         return "Stmt(%s)" % (repr(self.nodes),)
  1152.  
  1153. class Sub(Node):
  1154.     def __init__(self, (left, right), lineno=None):
  1155.         self.left = left
  1156.         self.right = right
  1157.         self.lineno = lineno
  1158.  
  1159.     def getChildren(self):
  1160.         return self.left, self.right
  1161.  
  1162.     def getChildNodes(self):
  1163.         return self.left, self.right
  1164.  
  1165.     def __repr__(self):
  1166.         return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
  1167.  
  1168. class Subscript(Node):
  1169.     def __init__(self, expr, flags, subs, lineno=None):
  1170.         self.expr = expr
  1171.         self.flags = flags
  1172.         self.subs = subs
  1173.         self.lineno = lineno
  1174.  
  1175.     def getChildren(self):
  1176.         children = []
  1177.         children.append(self.expr)
  1178.         children.append(self.flags)
  1179.         children.extend(flatten(self.subs))
  1180.         return tuple(children)
  1181.  
  1182.     def getChildNodes(self):
  1183.         nodelist = []
  1184.         nodelist.append(self.expr)
  1185.         nodelist.extend(flatten_nodes(self.subs))
  1186.         return tuple(nodelist)
  1187.  
  1188.     def __repr__(self):
  1189.         return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
  1190.  
  1191. class TryExcept(Node):
  1192.     def __init__(self, body, handlers, else_, lineno=None):
  1193.         self.body = body
  1194.         self.handlers = handlers
  1195.         self.else_ = else_
  1196.         self.lineno = lineno
  1197.  
  1198.     def getChildren(self):
  1199.         children = []
  1200.         children.append(self.body)
  1201.         children.extend(flatten(self.handlers))
  1202.         children.append(self.else_)
  1203.         return tuple(children)
  1204.  
  1205.     def getChildNodes(self):
  1206.         nodelist = []
  1207.         nodelist.append(self.body)
  1208.         nodelist.extend(flatten_nodes(self.handlers))
  1209.         if self.else_ is not None:
  1210.             nodelist.append(self.else_)
  1211.         return tuple(nodelist)
  1212.  
  1213.     def __repr__(self):
  1214.         return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
  1215.  
  1216. class TryFinally(Node):
  1217.     def __init__(self, body, final, lineno=None):
  1218.         self.body = body
  1219.         self.final = final
  1220.         self.lineno = lineno
  1221.  
  1222.     def getChildren(self):
  1223.         return self.body, self.final
  1224.  
  1225.     def getChildNodes(self):
  1226.         return self.body, self.final
  1227.  
  1228.     def __repr__(self):
  1229.         return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
  1230.  
  1231. class Tuple(Node):
  1232.     def __init__(self, nodes, lineno=None):
  1233.         self.nodes = nodes
  1234.         self.lineno = lineno
  1235.  
  1236.     def getChildren(self):
  1237.         return tuple(flatten(self.nodes))
  1238.  
  1239.     def getChildNodes(self):
  1240.         nodelist = []
  1241.         nodelist.extend(flatten_nodes(self.nodes))
  1242.         return tuple(nodelist)
  1243.  
  1244.     def __repr__(self):
  1245.         return "Tuple(%s)" % (repr(self.nodes),)
  1246.  
  1247. class UnaryAdd(Node):
  1248.     def __init__(self, expr, lineno=None):
  1249.         self.expr = expr
  1250.         self.lineno = lineno
  1251.  
  1252.     def getChildren(self):
  1253.         return self.expr,
  1254.  
  1255.     def getChildNodes(self):
  1256.         return self.expr,
  1257.  
  1258.     def __repr__(self):
  1259.         return "UnaryAdd(%s)" % (repr(self.expr),)
  1260.  
  1261. class UnarySub(Node):
  1262.     def __init__(self, expr, lineno=None):
  1263.         self.expr = expr
  1264.         self.lineno = lineno
  1265.  
  1266.     def getChildren(self):
  1267.         return self.expr,
  1268.  
  1269.     def getChildNodes(self):
  1270.         return self.expr,
  1271.  
  1272.     def __repr__(self):
  1273.         return "UnarySub(%s)" % (repr(self.expr),)
  1274.  
  1275. class While(Node):
  1276.     def __init__(self, test, body, else_, lineno=None):
  1277.         self.test = test
  1278.         self.body = body
  1279.         self.else_ = else_
  1280.         self.lineno = lineno
  1281.  
  1282.     def getChildren(self):
  1283.         children = []
  1284.         children.append(self.test)
  1285.         children.append(self.body)
  1286.         children.append(self.else_)
  1287.         return tuple(children)
  1288.  
  1289.     def getChildNodes(self):
  1290.         nodelist = []
  1291.         nodelist.append(self.test)
  1292.         nodelist.append(self.body)
  1293.         if self.else_ is not None:
  1294.             nodelist.append(self.else_)
  1295.         return tuple(nodelist)
  1296.  
  1297.     def __repr__(self):
  1298.         return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
  1299.  
  1300. class Yield(Node):
  1301.     def __init__(self, value, lineno=None):
  1302.         self.value = value
  1303.         self.lineno = lineno
  1304.  
  1305.     def getChildren(self):
  1306.         return self.value,
  1307.  
  1308.     def getChildNodes(self):
  1309.         return self.value,
  1310.  
  1311.     def __repr__(self):
  1312.         return "Yield(%s)" % (repr(self.value),)
  1313.  
  1314. for name, obj in globals().items():
  1315.     if isinstance(obj, type) and issubclass(obj, Node):
  1316.         nodes[name.lower()] = obj
  1317.